// Generated from E:\sol2bpel\grammar\SOL_Declarative.g4 by ANTLR 4.2
package qu.sol2bpel.sol.grammar;
import org.antlr.v4.runtime.atn.*;
import org.antlr.v4.runtime.dfa.DFA;
import org.antlr.v4.runtime.*;
import org.antlr.v4.runtime.misc.*;
import org.antlr.v4.runtime.tree.*;
import java.util.List;
import java.util.Iterator;
import java.util.ArrayList;

@SuppressWarnings({"all", "warnings", "unchecked", "unused", "cast"})
public class SOL_DeclarativeParser extends Parser {
	protected static final DFA[] _decisionToDFA;
	protected static final PredictionContextCache _sharedContextCache =
		new PredictionContextCache();
	public static final int
		PARTY=1, DATATYPE=2, SIMPLE_DATATYPE=3, VECTOR_DATATYPE=4, MATRIX_DATATYPE=5, 
		INPUT_KEYWORD=6, OUTPUT_KEYWORD=7, PROTOCOL_KEYWORD=8, DENY_KEYWORD=9, 
		FUNCTION_KEYWORD=10, VERIFICATION_KEYWORD=11, ID=12, INT=13, COLON=14, 
		LB=15, RB=16, COMMA=17, UNDER_SCORE=18, WS=19, NEWLINE=20;
	public static final String[] tokenNames = {
		"<INVALID>", "PARTY", "DATATYPE", "SIMPLE_DATATYPE", "VECTOR_DATATYPE", 
		"MATRIX_DATATYPE", "INPUT_KEYWORD", "OUTPUT_KEYWORD", "PROTOCOL_KEYWORD", 
		"DENY_KEYWORD", "FUNCTION_KEYWORD", "'Verification'", "ID", "INT", "':'", 
		"'('", "')'", "','", "'_'", "WS", "NEWLINE"
	};
	public static final int
		RULE_declarative_section = 0, RULE_parties_decl = 1, RULE_party_line_decl = 2, 
		RULE_var_decl = 3, RULE_var_line_decl = 4, RULE_input_output_decl = 5, 
		RULE_input_decl = 6, RULE_output_decl = 7, RULE_protocol_incl = 8, RULE_function_decl = 9, 
		RULE_deny_clause = 10, RULE_verification_clause = 11, RULE_var_list = 12, 
		RULE_vector_var_list = 13, RULE_matrix_var_list = 14, RULE_arg_list = 15;
	public static final String[] ruleNames = {
		"declarative_section", "parties_decl", "party_line_decl", "var_decl", 
		"var_line_decl", "input_output_decl", "input_decl", "output_decl", "protocol_incl", 
		"function_decl", "deny_clause", "verification_clause", "var_list", "vector_var_list", 
		"matrix_var_list", "arg_list"
	};

	@Override
	public String getGrammarFileName() { return "SOL_Declarative.g4"; }

	@Override
	public String[] getTokenNames() { return tokenNames; }

	@Override
	public String[] getRuleNames() { return ruleNames; }

	@Override
	public String getSerializedATN() { return _serializedATN; }

	@Override
	public ATN getATN() { return _ATN; }

	public SOL_DeclarativeParser(TokenStream input) {
		super(input);
		_interp = new ParserATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache);
	}
	public static class Declarative_sectionContext extends ParserRuleContext {
		public List<Protocol_inclContext> protocol_incl() {
			return getRuleContexts(Protocol_inclContext.class);
		}
		public Deny_clauseContext deny_clause(int i) {
			return getRuleContext(Deny_clauseContext.class,i);
		}
		public TerminalNode EOF() { return getToken(SOL_DeclarativeParser.EOF, 0); }
		public List<Deny_clauseContext> deny_clause() {
			return getRuleContexts(Deny_clauseContext.class);
		}
		public Function_declContext function_decl() {
			return getRuleContext(Function_declContext.class,0);
		}
		public Input_output_declContext input_output_decl() {
			return getRuleContext(Input_output_declContext.class,0);
		}
		public Var_declContext var_decl() {
			return getRuleContext(Var_declContext.class,0);
		}
		public Protocol_inclContext protocol_incl(int i) {
			return getRuleContext(Protocol_inclContext.class,i);
		}
		public List<Verification_clauseContext> verification_clause() {
			return getRuleContexts(Verification_clauseContext.class);
		}
		public Verification_clauseContext verification_clause(int i) {
			return getRuleContext(Verification_clauseContext.class,i);
		}
		public Parties_declContext parties_decl() {
			return getRuleContext(Parties_declContext.class,0);
		}
		public Declarative_sectionContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_declarative_section; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof SOL_DeclarativeListener ) ((SOL_DeclarativeListener)listener).enterDeclarative_section(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof SOL_DeclarativeListener ) ((SOL_DeclarativeListener)listener).exitDeclarative_section(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof SOL_DeclarativeVisitor ) return ((SOL_DeclarativeVisitor<? extends T>)visitor).visitDeclarative_section(this);
			else return visitor.visitChildren(this);
		}
	}

	public final Declarative_sectionContext declarative_section() throws RecognitionException {
		Declarative_sectionContext _localctx = new Declarative_sectionContext(_ctx, getState());
		enterRule(_localctx, 0, RULE_declarative_section);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(32); parties_decl();
			setState(33); var_decl();
			setState(34); input_output_decl();
			setState(38);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while (_la==PROTOCOL_KEYWORD) {
				{
				{
				setState(35); protocol_incl();
				}
				}
				setState(40);
				_errHandler.sync(this);
				_la = _input.LA(1);
			}
			setState(41); function_decl();
			setState(45);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while (_la==DENY_KEYWORD) {
				{
				{
				setState(42); deny_clause();
				}
				}
				setState(47);
				_errHandler.sync(this);
				_la = _input.LA(1);
			}
			setState(55);
			switch ( getInterpreter().adaptivePredict(_input,3,_ctx) ) {
			case 1:
				{
				setState(51);
				_errHandler.sync(this);
				_la = _input.LA(1);
				while (_la==VERIFICATION_KEYWORD) {
					{
					{
					setState(48); verification_clause();
					}
					}
					setState(53);
					_errHandler.sync(this);
					_la = _input.LA(1);
				}
				}
				break;

			case 2:
				{
				setState(54); match(EOF);
				}
				break;
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Parties_declContext extends ParserRuleContext {
		public Party_line_declContext party_line_decl(int i) {
			return getRuleContext(Party_line_declContext.class,i);
		}
		public List<Party_line_declContext> party_line_decl() {
			return getRuleContexts(Party_line_declContext.class);
		}
		public Parties_declContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_parties_decl; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof SOL_DeclarativeListener ) ((SOL_DeclarativeListener)listener).enterParties_decl(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof SOL_DeclarativeListener ) ((SOL_DeclarativeListener)listener).exitParties_decl(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof SOL_DeclarativeVisitor ) return ((SOL_DeclarativeVisitor<? extends T>)visitor).visitParties_decl(this);
			else return visitor.visitChildren(this);
		}
	}

	public final Parties_declContext parties_decl() throws RecognitionException {
		Parties_declContext _localctx = new Parties_declContext(_ctx, getState());
		enterRule(_localctx, 2, RULE_parties_decl);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(58); 
			_errHandler.sync(this);
			_la = _input.LA(1);
			do {
				{
				{
				setState(57); party_line_decl();
				}
				}
				setState(60); 
				_errHandler.sync(this);
				_la = _input.LA(1);
			} while ( _la==PARTY );
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Party_line_declContext extends ParserRuleContext {
		public TerminalNode NEWLINE() { return getToken(SOL_DeclarativeParser.NEWLINE, 0); }
		public TerminalNode PARTY() { return getToken(SOL_DeclarativeParser.PARTY, 0); }
		public List<TerminalNode> COMMA() { return getTokens(SOL_DeclarativeParser.COMMA); }
		public List<TerminalNode> ID() { return getTokens(SOL_DeclarativeParser.ID); }
		public TerminalNode COMMA(int i) {
			return getToken(SOL_DeclarativeParser.COMMA, i);
		}
		public TerminalNode ID(int i) {
			return getToken(SOL_DeclarativeParser.ID, i);
		}
		public Party_line_declContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_party_line_decl; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof SOL_DeclarativeListener ) ((SOL_DeclarativeListener)listener).enterParty_line_decl(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof SOL_DeclarativeListener ) ((SOL_DeclarativeListener)listener).exitParty_line_decl(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof SOL_DeclarativeVisitor ) return ((SOL_DeclarativeVisitor<? extends T>)visitor).visitParty_line_decl(this);
			else return visitor.visitChildren(this);
		}
	}

	public final Party_line_declContext party_line_decl() throws RecognitionException {
		Party_line_declContext _localctx = new Party_line_declContext(_ctx, getState());
		enterRule(_localctx, 4, RULE_party_line_decl);
		try {
			int _alt;
			setState(75);
			switch ( getInterpreter().adaptivePredict(_input,6,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(62); match(PARTY);
				setState(63); match(ID);
				setState(64); match(NEWLINE);
				}
				break;

			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(65); match(PARTY);
				setState(70);
				_errHandler.sync(this);
				_alt = getInterpreter().adaptivePredict(_input,5,_ctx);
				while ( _alt!=2 && _alt!=-1 ) {
					if ( _alt==1 ) {
						{
						{
						setState(66); match(ID);
						setState(67); match(COMMA);
						}
						} 
					}
					setState(72);
					_errHandler.sync(this);
					_alt = getInterpreter().adaptivePredict(_input,5,_ctx);
				}
				setState(73); match(ID);
				setState(74); match(NEWLINE);
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Var_declContext extends ParserRuleContext {
		public List<Var_line_declContext> var_line_decl() {
			return getRuleContexts(Var_line_declContext.class);
		}
		public Var_line_declContext var_line_decl(int i) {
			return getRuleContext(Var_line_declContext.class,i);
		}
		public Var_declContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_var_decl; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof SOL_DeclarativeListener ) ((SOL_DeclarativeListener)listener).enterVar_decl(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof SOL_DeclarativeListener ) ((SOL_DeclarativeListener)listener).exitVar_decl(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof SOL_DeclarativeVisitor ) return ((SOL_DeclarativeVisitor<? extends T>)visitor).visitVar_decl(this);
			else return visitor.visitChildren(this);
		}
	}

	public final Var_declContext var_decl() throws RecognitionException {
		Var_declContext _localctx = new Var_declContext(_ctx, getState());
		enterRule(_localctx, 6, RULE_var_decl);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(78); 
			_errHandler.sync(this);
			_la = _input.LA(1);
			do {
				{
				{
				setState(77); var_line_decl();
				}
				}
				setState(80); 
				_errHandler.sync(this);
				_la = _input.LA(1);
			} while ( _la==DATATYPE );
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Var_line_declContext extends ParserRuleContext {
		public TerminalNode NEWLINE() { return getToken(SOL_DeclarativeParser.NEWLINE, 0); }
		public Var_listContext var_list() {
			return getRuleContext(Var_listContext.class,0);
		}
		public Matrix_var_listContext matrix_var_list() {
			return getRuleContext(Matrix_var_listContext.class,0);
		}
		public TerminalNode DATATYPE() { return getToken(SOL_DeclarativeParser.DATATYPE, 0); }
		public Vector_var_listContext vector_var_list() {
			return getRuleContext(Vector_var_listContext.class,0);
		}
		public Var_line_declContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_var_line_decl; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof SOL_DeclarativeListener ) ((SOL_DeclarativeListener)listener).enterVar_line_decl(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof SOL_DeclarativeListener ) ((SOL_DeclarativeListener)listener).exitVar_line_decl(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof SOL_DeclarativeVisitor ) return ((SOL_DeclarativeVisitor<? extends T>)visitor).visitVar_line_decl(this);
			else return visitor.visitChildren(this);
		}
	}

	public final Var_line_declContext var_line_decl() throws RecognitionException {
		Var_line_declContext _localctx = new Var_line_declContext(_ctx, getState());
		enterRule(_localctx, 8, RULE_var_line_decl);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(82); match(DATATYPE);
			setState(86);
			switch ( getInterpreter().adaptivePredict(_input,8,_ctx) ) {
			case 1:
				{
				setState(83); var_list();
				}
				break;

			case 2:
				{
				setState(84); vector_var_list();
				}
				break;

			case 3:
				{
				setState(85); matrix_var_list();
				}
				break;
			}
			setState(88); match(NEWLINE);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Input_output_declContext extends ParserRuleContext {
		public List<Output_declContext> output_decl() {
			return getRuleContexts(Output_declContext.class);
		}
		public List<Input_declContext> input_decl() {
			return getRuleContexts(Input_declContext.class);
		}
		public Input_declContext input_decl(int i) {
			return getRuleContext(Input_declContext.class,i);
		}
		public Output_declContext output_decl(int i) {
			return getRuleContext(Output_declContext.class,i);
		}
		public Input_output_declContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_input_output_decl; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof SOL_DeclarativeListener ) ((SOL_DeclarativeListener)listener).enterInput_output_decl(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof SOL_DeclarativeListener ) ((SOL_DeclarativeListener)listener).exitInput_output_decl(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof SOL_DeclarativeVisitor ) return ((SOL_DeclarativeVisitor<? extends T>)visitor).visitInput_output_decl(this);
			else return visitor.visitChildren(this);
		}
	}

	public final Input_output_declContext input_output_decl() throws RecognitionException {
		Input_output_declContext _localctx = new Input_output_declContext(_ctx, getState());
		enterRule(_localctx, 10, RULE_input_output_decl);
		try {
			int _alt;
			enterOuterAlt(_localctx, 1);
			{
			setState(91); 
			_errHandler.sync(this);
			_alt = getInterpreter().adaptivePredict(_input,9,_ctx);
			do {
				switch (_alt) {
				case 1:
					{
					{
					setState(90); input_decl();
					}
					}
					break;
				default:
					throw new NoViableAltException(this);
				}
				setState(93); 
				_errHandler.sync(this);
				_alt = getInterpreter().adaptivePredict(_input,9,_ctx);
			} while ( _alt!=2 && _alt!=-1 );
			setState(96); 
			_errHandler.sync(this);
			_alt = getInterpreter().adaptivePredict(_input,10,_ctx);
			do {
				switch (_alt) {
				case 1:
					{
					{
					setState(95); output_decl();
					}
					}
					break;
				default:
					throw new NoViableAltException(this);
				}
				setState(98); 
				_errHandler.sync(this);
				_alt = getInterpreter().adaptivePredict(_input,10,_ctx);
			} while ( _alt!=2 && _alt!=-1 );
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Input_declContext extends ParserRuleContext {
		public TerminalNode NEWLINE() { return getToken(SOL_DeclarativeParser.NEWLINE, 0); }
		public TerminalNode INPUT_KEYWORD() { return getToken(SOL_DeclarativeParser.INPUT_KEYWORD, 0); }
		public Var_listContext var_list() {
			return getRuleContext(Var_listContext.class,0);
		}
		public TerminalNode ID() { return getToken(SOL_DeclarativeParser.ID, 0); }
		public TerminalNode COLON() { return getToken(SOL_DeclarativeParser.COLON, 0); }
		public Input_declContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_input_decl; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof SOL_DeclarativeListener ) ((SOL_DeclarativeListener)listener).enterInput_decl(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof SOL_DeclarativeListener ) ((SOL_DeclarativeListener)listener).exitInput_decl(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof SOL_DeclarativeVisitor ) return ((SOL_DeclarativeVisitor<? extends T>)visitor).visitInput_decl(this);
			else return visitor.visitChildren(this);
		}
	}

	public final Input_declContext input_decl() throws RecognitionException {
		Input_declContext _localctx = new Input_declContext(_ctx, getState());
		enterRule(_localctx, 12, RULE_input_decl);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(100); match(ID);
			setState(101); match(COLON);
			setState(102); match(INPUT_KEYWORD);
			setState(103); var_list();
			setState(104); match(NEWLINE);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Output_declContext extends ParserRuleContext {
		public TerminalNode NEWLINE() { return getToken(SOL_DeclarativeParser.NEWLINE, 0); }
		public Var_listContext var_list() {
			return getRuleContext(Var_listContext.class,0);
		}
		public TerminalNode OUTPUT_KEYWORD() { return getToken(SOL_DeclarativeParser.OUTPUT_KEYWORD, 0); }
		public TerminalNode ID() { return getToken(SOL_DeclarativeParser.ID, 0); }
		public TerminalNode COLON() { return getToken(SOL_DeclarativeParser.COLON, 0); }
		public Output_declContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_output_decl; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof SOL_DeclarativeListener ) ((SOL_DeclarativeListener)listener).enterOutput_decl(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof SOL_DeclarativeListener ) ((SOL_DeclarativeListener)listener).exitOutput_decl(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof SOL_DeclarativeVisitor ) return ((SOL_DeclarativeVisitor<? extends T>)visitor).visitOutput_decl(this);
			else return visitor.visitChildren(this);
		}
	}

	public final Output_declContext output_decl() throws RecognitionException {
		Output_declContext _localctx = new Output_declContext(_ctx, getState());
		enterRule(_localctx, 14, RULE_output_decl);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(106); match(ID);
			setState(107); match(COLON);
			setState(108); match(OUTPUT_KEYWORD);
			setState(109); var_list();
			setState(110); match(NEWLINE);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Protocol_inclContext extends ParserRuleContext {
		public List<TerminalNode> NEWLINE() { return getTokens(SOL_DeclarativeParser.NEWLINE); }
		public TerminalNode RB(int i) {
			return getToken(SOL_DeclarativeParser.RB, i);
		}
		public List<TerminalNode> LB() { return getTokens(SOL_DeclarativeParser.LB); }
		public TerminalNode NEWLINE(int i) {
			return getToken(SOL_DeclarativeParser.NEWLINE, i);
		}
		public TerminalNode LB(int i) {
			return getToken(SOL_DeclarativeParser.LB, i);
		}
		public List<TerminalNode> RB() { return getTokens(SOL_DeclarativeParser.RB); }
		public List<Arg_listContext> arg_list() {
			return getRuleContexts(Arg_listContext.class);
		}
		public List<TerminalNode> ID() { return getTokens(SOL_DeclarativeParser.ID); }
		public List<TerminalNode> PROTOCOL_KEYWORD() { return getTokens(SOL_DeclarativeParser.PROTOCOL_KEYWORD); }
		public Arg_listContext arg_list(int i) {
			return getRuleContext(Arg_listContext.class,i);
		}
		public TerminalNode ID(int i) {
			return getToken(SOL_DeclarativeParser.ID, i);
		}
		public TerminalNode PROTOCOL_KEYWORD(int i) {
			return getToken(SOL_DeclarativeParser.PROTOCOL_KEYWORD, i);
		}
		public Protocol_inclContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_protocol_incl; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof SOL_DeclarativeListener ) ((SOL_DeclarativeListener)listener).enterProtocol_incl(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof SOL_DeclarativeListener ) ((SOL_DeclarativeListener)listener).exitProtocol_incl(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof SOL_DeclarativeVisitor ) return ((SOL_DeclarativeVisitor<? extends T>)visitor).visitProtocol_incl(this);
			else return visitor.visitChildren(this);
		}
	}

	public final Protocol_inclContext protocol_incl() throws RecognitionException {
		Protocol_inclContext _localctx = new Protocol_inclContext(_ctx, getState());
		enterRule(_localctx, 16, RULE_protocol_incl);
		int _la;
		try {
			int _alt;
			enterOuterAlt(_localctx, 1);
			{
			setState(123); 
			_errHandler.sync(this);
			_alt = getInterpreter().adaptivePredict(_input,12,_ctx);
			do {
				switch (_alt) {
				case 1:
					{
					{
					setState(112); match(PROTOCOL_KEYWORD);
					setState(113); match(ID);
					setState(114); match(LB);
					setState(118);
					_errHandler.sync(this);
					_la = _input.LA(1);
					while (_la==DATATYPE) {
						{
						{
						setState(115); arg_list();
						}
						}
						setState(120);
						_errHandler.sync(this);
						_la = _input.LA(1);
					}
					setState(121); match(RB);
					setState(122); match(NEWLINE);
					}
					}
					break;
				default:
					throw new NoViableAltException(this);
				}
				setState(125); 
				_errHandler.sync(this);
				_alt = getInterpreter().adaptivePredict(_input,12,_ctx);
			} while ( _alt!=2 && _alt!=-1 );
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Function_declContext extends ParserRuleContext {
		public TerminalNode NEWLINE(int i) {
			return getToken(SOL_DeclarativeParser.NEWLINE, i);
		}
		public List<TerminalNode> ID() { return getTokens(SOL_DeclarativeParser.ID); }
		public Arg_listContext arg_list(int i) {
			return getRuleContext(Arg_listContext.class,i);
		}
		public TerminalNode RB(int i) {
			return getToken(SOL_DeclarativeParser.RB, i);
		}
		public List<TerminalNode> NEWLINE() { return getTokens(SOL_DeclarativeParser.NEWLINE); }
		public List<TerminalNode> LB() { return getTokens(SOL_DeclarativeParser.LB); }
		public List<TerminalNode> FUNCTION_KEYWORD() { return getTokens(SOL_DeclarativeParser.FUNCTION_KEYWORD); }
		public TerminalNode LB(int i) {
			return getToken(SOL_DeclarativeParser.LB, i);
		}
		public List<TerminalNode> RB() { return getTokens(SOL_DeclarativeParser.RB); }
		public List<Arg_listContext> arg_list() {
			return getRuleContexts(Arg_listContext.class);
		}
		public TerminalNode COLON(int i) {
			return getToken(SOL_DeclarativeParser.COLON, i);
		}
		public TerminalNode FUNCTION_KEYWORD(int i) {
			return getToken(SOL_DeclarativeParser.FUNCTION_KEYWORD, i);
		}
		public List<TerminalNode> COLON() { return getTokens(SOL_DeclarativeParser.COLON); }
		public TerminalNode ID(int i) {
			return getToken(SOL_DeclarativeParser.ID, i);
		}
		public Function_declContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_function_decl; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof SOL_DeclarativeListener ) ((SOL_DeclarativeListener)listener).enterFunction_decl(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof SOL_DeclarativeListener ) ((SOL_DeclarativeListener)listener).exitFunction_decl(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof SOL_DeclarativeVisitor ) return ((SOL_DeclarativeVisitor<? extends T>)visitor).visitFunction_decl(this);
			else return visitor.visitChildren(this);
		}
	}

	public final Function_declContext function_decl() throws RecognitionException {
		Function_declContext _localctx = new Function_declContext(_ctx, getState());
		enterRule(_localctx, 18, RULE_function_decl);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(142); 
			_errHandler.sync(this);
			_la = _input.LA(1);
			do {
				{
				{
				setState(129);
				_la = _input.LA(1);
				if (_la==ID) {
					{
					setState(127); match(ID);
					setState(128); match(COLON);
					}
				}

				setState(131); match(FUNCTION_KEYWORD);
				setState(132); match(ID);
				setState(133); match(LB);
				setState(137);
				_errHandler.sync(this);
				_la = _input.LA(1);
				while (_la==DATATYPE) {
					{
					{
					setState(134); arg_list();
					}
					}
					setState(139);
					_errHandler.sync(this);
					_la = _input.LA(1);
				}
				setState(140); match(RB);
				setState(141); match(NEWLINE);
				}
				}
				setState(144); 
				_errHandler.sync(this);
				_la = _input.LA(1);
			} while ( _la==FUNCTION_KEYWORD || _la==ID );
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Deny_clauseContext extends ParserRuleContext {
		public TerminalNode NEWLINE() { return getToken(SOL_DeclarativeParser.NEWLINE, 0); }
		public Var_listContext var_list() {
			return getRuleContext(Var_listContext.class,0);
		}
		public TerminalNode DENY_KEYWORD() { return getToken(SOL_DeclarativeParser.DENY_KEYWORD, 0); }
		public TerminalNode ID() { return getToken(SOL_DeclarativeParser.ID, 0); }
		public Deny_clauseContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_deny_clause; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof SOL_DeclarativeListener ) ((SOL_DeclarativeListener)listener).enterDeny_clause(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof SOL_DeclarativeListener ) ((SOL_DeclarativeListener)listener).exitDeny_clause(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof SOL_DeclarativeVisitor ) return ((SOL_DeclarativeVisitor<? extends T>)visitor).visitDeny_clause(this);
			else return visitor.visitChildren(this);
		}
	}

	public final Deny_clauseContext deny_clause() throws RecognitionException {
		Deny_clauseContext _localctx = new Deny_clauseContext(_ctx, getState());
		enterRule(_localctx, 20, RULE_deny_clause);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(146); match(DENY_KEYWORD);
			setState(147); match(ID);
			setState(148); match(COLON);
			setState(149); var_list();
			setState(150); match(NEWLINE);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Verification_clauseContext extends ParserRuleContext {
		public TerminalNode NEWLINE() { return getToken(SOL_DeclarativeParser.NEWLINE, 0); }
		public TerminalNode EOF() { return getToken(SOL_DeclarativeParser.EOF, 0); }
		public TerminalNode LB() { return getToken(SOL_DeclarativeParser.LB, 0); }
		public TerminalNode VERIFICATION_KEYWORD() { return getToken(SOL_DeclarativeParser.VERIFICATION_KEYWORD, 0); }
		public TerminalNode RB() { return getToken(SOL_DeclarativeParser.RB, 0); }
		public Var_listContext var_list() {
			return getRuleContext(Var_listContext.class,0);
		}
		public List<TerminalNode> ID() { return getTokens(SOL_DeclarativeParser.ID); }
		public TerminalNode COLON() { return getToken(SOL_DeclarativeParser.COLON, 0); }
		public TerminalNode ID(int i) {
			return getToken(SOL_DeclarativeParser.ID, i);
		}
		public Verification_clauseContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_verification_clause; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof SOL_DeclarativeListener ) ((SOL_DeclarativeListener)listener).enterVerification_clause(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof SOL_DeclarativeListener ) ((SOL_DeclarativeListener)listener).exitVerification_clause(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof SOL_DeclarativeVisitor ) return ((SOL_DeclarativeVisitor<? extends T>)visitor).visitVerification_clause(this);
			else return visitor.visitChildren(this);
		}
	}

	public final Verification_clauseContext verification_clause() throws RecognitionException {
		Verification_clauseContext _localctx = new Verification_clauseContext(_ctx, getState());
		enterRule(_localctx, 22, RULE_verification_clause);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(152); match(VERIFICATION_KEYWORD);
			setState(153); match(ID);
			setState(154); match(COLON);
			setState(155); match(ID);
			setState(156); match(LB);
			setState(157); var_list();
			setState(158); match(RB);
			setState(159);
			_la = _input.LA(1);
			if ( !(_la==EOF || _la==NEWLINE) ) {
			_errHandler.recoverInline(this);
			}
			consume();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Var_listContext extends ParserRuleContext {
		public List<TerminalNode> COMMA() { return getTokens(SOL_DeclarativeParser.COMMA); }
		public List<TerminalNode> ID() { return getTokens(SOL_DeclarativeParser.ID); }
		public TerminalNode COMMA(int i) {
			return getToken(SOL_DeclarativeParser.COMMA, i);
		}
		public TerminalNode ID(int i) {
			return getToken(SOL_DeclarativeParser.ID, i);
		}
		public Var_listContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_var_list; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof SOL_DeclarativeListener ) ((SOL_DeclarativeListener)listener).enterVar_list(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof SOL_DeclarativeListener ) ((SOL_DeclarativeListener)listener).exitVar_list(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof SOL_DeclarativeVisitor ) return ((SOL_DeclarativeVisitor<? extends T>)visitor).visitVar_list(this);
			else return visitor.visitChildren(this);
		}
	}

	public final Var_listContext var_list() throws RecognitionException {
		Var_listContext _localctx = new Var_listContext(_ctx, getState());
		enterRule(_localctx, 24, RULE_var_list);
		try {
			int _alt;
			enterOuterAlt(_localctx, 1);
			{
			setState(165);
			_errHandler.sync(this);
			_alt = getInterpreter().adaptivePredict(_input,16,_ctx);
			while ( _alt!=2 && _alt!=-1 ) {
				if ( _alt==1 ) {
					{
					{
					setState(161); match(ID);
					setState(162); match(COMMA);
					}
					} 
				}
				setState(167);
				_errHandler.sync(this);
				_alt = getInterpreter().adaptivePredict(_input,16,_ctx);
			}
			setState(168); match(ID);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Vector_var_listContext extends ParserRuleContext {
		public TerminalNode RB(int i) {
			return getToken(SOL_DeclarativeParser.RB, i);
		}
		public List<TerminalNode> LB() { return getTokens(SOL_DeclarativeParser.LB); }
		public List<TerminalNode> INT() { return getTokens(SOL_DeclarativeParser.INT); }
		public TerminalNode LB(int i) {
			return getToken(SOL_DeclarativeParser.LB, i);
		}
		public List<TerminalNode> RB() { return getTokens(SOL_DeclarativeParser.RB); }
		public Var_listContext var_list() {
			return getRuleContext(Var_listContext.class,0);
		}
		public List<TerminalNode> COMMA() { return getTokens(SOL_DeclarativeParser.COMMA); }
		public List<TerminalNode> ID() { return getTokens(SOL_DeclarativeParser.ID); }
		public TerminalNode INT(int i) {
			return getToken(SOL_DeclarativeParser.INT, i);
		}
		public TerminalNode COMMA(int i) {
			return getToken(SOL_DeclarativeParser.COMMA, i);
		}
		public TerminalNode ID(int i) {
			return getToken(SOL_DeclarativeParser.ID, i);
		}
		public Vector_var_listContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_vector_var_list; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof SOL_DeclarativeListener ) ((SOL_DeclarativeListener)listener).enterVector_var_list(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof SOL_DeclarativeListener ) ((SOL_DeclarativeListener)listener).exitVector_var_list(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof SOL_DeclarativeVisitor ) return ((SOL_DeclarativeVisitor<? extends T>)visitor).visitVector_var_list(this);
			else return visitor.visitChildren(this);
		}
	}

	public final Vector_var_listContext vector_var_list() throws RecognitionException {
		Vector_var_listContext _localctx = new Vector_var_listContext(_ctx, getState());
		enterRule(_localctx, 26, RULE_vector_var_list);
		int _la;
		try {
			int _alt;
			setState(185);
			switch ( getInterpreter().adaptivePredict(_input,18,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(170); var_list();
				}
				break;

			case 2:
				enterOuterAlt(_localctx, 2);
				{
				{
				setState(178);
				_errHandler.sync(this);
				_alt = getInterpreter().adaptivePredict(_input,17,_ctx);
				while ( _alt!=2 && _alt!=-1 ) {
					if ( _alt==1 ) {
						{
						{
						setState(171); match(ID);
						setState(172); match(LB);
						setState(173);
						_la = _input.LA(1);
						if ( !(_la==ID || _la==INT) ) {
						_errHandler.recoverInline(this);
						}
						consume();
						setState(174); match(RB);
						setState(175); match(COMMA);
						}
						} 
					}
					setState(180);
					_errHandler.sync(this);
					_alt = getInterpreter().adaptivePredict(_input,17,_ctx);
				}
				{
				setState(181); match(ID);
				setState(182); match(LB);
				setState(183);
				_la = _input.LA(1);
				if ( !(_la==ID || _la==INT) ) {
				_errHandler.recoverInline(this);
				}
				consume();
				setState(184); match(RB);
				}
				}
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Matrix_var_listContext extends ParserRuleContext {
		public TerminalNode RB(int i) {
			return getToken(SOL_DeclarativeParser.RB, i);
		}
		public List<TerminalNode> LB() { return getTokens(SOL_DeclarativeParser.LB); }
		public List<TerminalNode> INT() { return getTokens(SOL_DeclarativeParser.INT); }
		public TerminalNode LB(int i) {
			return getToken(SOL_DeclarativeParser.LB, i);
		}
		public List<TerminalNode> RB() { return getTokens(SOL_DeclarativeParser.RB); }
		public Var_listContext var_list() {
			return getRuleContext(Var_listContext.class,0);
		}
		public List<TerminalNode> COMMA() { return getTokens(SOL_DeclarativeParser.COMMA); }
		public List<TerminalNode> ID() { return getTokens(SOL_DeclarativeParser.ID); }
		public TerminalNode INT(int i) {
			return getToken(SOL_DeclarativeParser.INT, i);
		}
		public TerminalNode COMMA(int i) {
			return getToken(SOL_DeclarativeParser.COMMA, i);
		}
		public TerminalNode ID(int i) {
			return getToken(SOL_DeclarativeParser.ID, i);
		}
		public Matrix_var_listContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_matrix_var_list; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof SOL_DeclarativeListener ) ((SOL_DeclarativeListener)listener).enterMatrix_var_list(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof SOL_DeclarativeListener ) ((SOL_DeclarativeListener)listener).exitMatrix_var_list(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof SOL_DeclarativeVisitor ) return ((SOL_DeclarativeVisitor<? extends T>)visitor).visitMatrix_var_list(this);
			else return visitor.visitChildren(this);
		}
	}

	public final Matrix_var_listContext matrix_var_list() throws RecognitionException {
		Matrix_var_listContext _localctx = new Matrix_var_listContext(_ctx, getState());
		enterRule(_localctx, 28, RULE_matrix_var_list);
		int _la;
		try {
			int _alt;
			setState(206);
			switch ( getInterpreter().adaptivePredict(_input,20,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(187); var_list();
				}
				break;

			case 2:
				enterOuterAlt(_localctx, 2);
				{
				{
				setState(197);
				_errHandler.sync(this);
				_alt = getInterpreter().adaptivePredict(_input,19,_ctx);
				while ( _alt!=2 && _alt!=-1 ) {
					if ( _alt==1 ) {
						{
						{
						setState(188); match(ID);
						setState(189); match(LB);
						setState(190);
						_la = _input.LA(1);
						if ( !(_la==ID || _la==INT) ) {
						_errHandler.recoverInline(this);
						}
						consume();
						setState(191); match(COMMA);
						setState(192);
						_la = _input.LA(1);
						if ( !(_la==ID || _la==INT) ) {
						_errHandler.recoverInline(this);
						}
						consume();
						setState(193); match(RB);
						setState(194); match(COMMA);
						}
						} 
					}
					setState(199);
					_errHandler.sync(this);
					_alt = getInterpreter().adaptivePredict(_input,19,_ctx);
				}
				{
				setState(200); match(ID);
				setState(201); match(LB);
				setState(202);
				_la = _input.LA(1);
				if ( !(_la==ID || _la==INT) ) {
				_errHandler.recoverInline(this);
				}
				consume();
				setState(203); match(COMMA);
				setState(204);
				_la = _input.LA(1);
				if ( !(_la==ID || _la==INT) ) {
				_errHandler.recoverInline(this);
				}
				consume();
				setState(205); match(RB);
				}
				}
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Arg_listContext extends ParserRuleContext {
		public List<TerminalNode> COMMA() { return getTokens(SOL_DeclarativeParser.COMMA); }
		public List<TerminalNode> ID() { return getTokens(SOL_DeclarativeParser.ID); }
		public TerminalNode DATATYPE(int i) {
			return getToken(SOL_DeclarativeParser.DATATYPE, i);
		}
		public List<TerminalNode> DATATYPE() { return getTokens(SOL_DeclarativeParser.DATATYPE); }
		public TerminalNode COMMA(int i) {
			return getToken(SOL_DeclarativeParser.COMMA, i);
		}
		public TerminalNode ID(int i) {
			return getToken(SOL_DeclarativeParser.ID, i);
		}
		public Arg_listContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_arg_list; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof SOL_DeclarativeListener ) ((SOL_DeclarativeListener)listener).enterArg_list(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof SOL_DeclarativeListener ) ((SOL_DeclarativeListener)listener).exitArg_list(this);
		}
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof SOL_DeclarativeVisitor ) return ((SOL_DeclarativeVisitor<? extends T>)visitor).visitArg_list(this);
			else return visitor.visitChildren(this);
		}
	}

	public final Arg_listContext arg_list() throws RecognitionException {
		Arg_listContext _localctx = new Arg_listContext(_ctx, getState());
		enterRule(_localctx, 30, RULE_arg_list);
		try {
			int _alt;
			enterOuterAlt(_localctx, 1);
			{
			setState(213);
			_errHandler.sync(this);
			_alt = getInterpreter().adaptivePredict(_input,21,_ctx);
			while ( _alt!=2 && _alt!=-1 ) {
				if ( _alt==1 ) {
					{
					{
					setState(208); match(DATATYPE);
					setState(209); match(ID);
					setState(210); match(COMMA);
					}
					} 
				}
				setState(215);
				_errHandler.sync(this);
				_alt = getInterpreter().adaptivePredict(_input,21,_ctx);
			}
			setState(216); match(DATATYPE);
			setState(217); match(ID);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static final String _serializedATN =
		"\3\u0430\ud6d1\u8206\uad2d\u4417\uaef1\u8d80\uaadd\3\26\u00de\4\2\t\2"+
		"\4\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t\7\4\b\t\b\4\t\t\t\4\n\t\n\4\13"+
		"\t\13\4\f\t\f\4\r\t\r\4\16\t\16\4\17\t\17\4\20\t\20\4\21\t\21\3\2\3\2"+
		"\3\2\3\2\7\2\'\n\2\f\2\16\2*\13\2\3\2\3\2\7\2.\n\2\f\2\16\2\61\13\2\3"+
		"\2\7\2\64\n\2\f\2\16\2\67\13\2\3\2\5\2:\n\2\3\3\6\3=\n\3\r\3\16\3>\3\4"+
		"\3\4\3\4\3\4\3\4\3\4\7\4G\n\4\f\4\16\4J\13\4\3\4\3\4\5\4N\n\4\3\5\6\5"+
		"Q\n\5\r\5\16\5R\3\6\3\6\3\6\3\6\5\6Y\n\6\3\6\3\6\3\7\6\7^\n\7\r\7\16\7"+
		"_\3\7\6\7c\n\7\r\7\16\7d\3\b\3\b\3\b\3\b\3\b\3\b\3\t\3\t\3\t\3\t\3\t\3"+
		"\t\3\n\3\n\3\n\3\n\7\nw\n\n\f\n\16\nz\13\n\3\n\3\n\6\n~\n\n\r\n\16\n\177"+
		"\3\13\3\13\5\13\u0084\n\13\3\13\3\13\3\13\3\13\7\13\u008a\n\13\f\13\16"+
		"\13\u008d\13\13\3\13\3\13\6\13\u0091\n\13\r\13\16\13\u0092\3\f\3\f\3\f"+
		"\3\f\3\f\3\f\3\r\3\r\3\r\3\r\3\r\3\r\3\r\3\r\3\r\3\16\3\16\7\16\u00a6"+
		"\n\16\f\16\16\16\u00a9\13\16\3\16\3\16\3\17\3\17\3\17\3\17\3\17\3\17\7"+
		"\17\u00b3\n\17\f\17\16\17\u00b6\13\17\3\17\3\17\3\17\3\17\5\17\u00bc\n"+
		"\17\3\20\3\20\3\20\3\20\3\20\3\20\3\20\3\20\7\20\u00c6\n\20\f\20\16\20"+
		"\u00c9\13\20\3\20\3\20\3\20\3\20\3\20\3\20\5\20\u00d1\n\20\3\21\3\21\3"+
		"\21\7\21\u00d6\n\21\f\21\16\21\u00d9\13\21\3\21\3\21\3\21\3\21\2\2\22"+
		"\2\4\6\b\n\f\16\20\22\24\26\30\32\34\36 \2\4\3\3\26\26\3\2\16\17\u00e4"+
		"\2\"\3\2\2\2\4<\3\2\2\2\6M\3\2\2\2\bP\3\2\2\2\nT\3\2\2\2\f]\3\2\2\2\16"+
		"f\3\2\2\2\20l\3\2\2\2\22}\3\2\2\2\24\u0090\3\2\2\2\26\u0094\3\2\2\2\30"+
		"\u009a\3\2\2\2\32\u00a7\3\2\2\2\34\u00bb\3\2\2\2\36\u00d0\3\2\2\2 \u00d7"+
		"\3\2\2\2\"#\5\4\3\2#$\5\b\5\2$(\5\f\7\2%\'\5\22\n\2&%\3\2\2\2\'*\3\2\2"+
		"\2(&\3\2\2\2()\3\2\2\2)+\3\2\2\2*(\3\2\2\2+/\5\24\13\2,.\5\26\f\2-,\3"+
		"\2\2\2.\61\3\2\2\2/-\3\2\2\2/\60\3\2\2\2\609\3\2\2\2\61/\3\2\2\2\62\64"+
		"\5\30\r\2\63\62\3\2\2\2\64\67\3\2\2\2\65\63\3\2\2\2\65\66\3\2\2\2\66:"+
		"\3\2\2\2\67\65\3\2\2\28:\7\2\2\39\65\3\2\2\298\3\2\2\2:\3\3\2\2\2;=\5"+
		"\6\4\2<;\3\2\2\2=>\3\2\2\2><\3\2\2\2>?\3\2\2\2?\5\3\2\2\2@A\7\3\2\2AB"+
		"\7\16\2\2BN\7\26\2\2CH\7\3\2\2DE\7\16\2\2EG\7\23\2\2FD\3\2\2\2GJ\3\2\2"+
		"\2HF\3\2\2\2HI\3\2\2\2IK\3\2\2\2JH\3\2\2\2KL\7\16\2\2LN\7\26\2\2M@\3\2"+
		"\2\2MC\3\2\2\2N\7\3\2\2\2OQ\5\n\6\2PO\3\2\2\2QR\3\2\2\2RP\3\2\2\2RS\3"+
		"\2\2\2S\t\3\2\2\2TX\7\4\2\2UY\5\32\16\2VY\5\34\17\2WY\5\36\20\2XU\3\2"+
		"\2\2XV\3\2\2\2XW\3\2\2\2YZ\3\2\2\2Z[\7\26\2\2[\13\3\2\2\2\\^\5\16\b\2"+
		"]\\\3\2\2\2^_\3\2\2\2_]\3\2\2\2_`\3\2\2\2`b\3\2\2\2ac\5\20\t\2ba\3\2\2"+
		"\2cd\3\2\2\2db\3\2\2\2de\3\2\2\2e\r\3\2\2\2fg\7\16\2\2gh\7\20\2\2hi\7"+
		"\b\2\2ij\5\32\16\2jk\7\26\2\2k\17\3\2\2\2lm\7\16\2\2mn\7\20\2\2no\7\t"+
		"\2\2op\5\32\16\2pq\7\26\2\2q\21\3\2\2\2rs\7\n\2\2st\7\16\2\2tx\7\21\2"+
		"\2uw\5 \21\2vu\3\2\2\2wz\3\2\2\2xv\3\2\2\2xy\3\2\2\2y{\3\2\2\2zx\3\2\2"+
		"\2{|\7\22\2\2|~\7\26\2\2}r\3\2\2\2~\177\3\2\2\2\177}\3\2\2\2\177\u0080"+
		"\3\2\2\2\u0080\23\3\2\2\2\u0081\u0082\7\16\2\2\u0082\u0084\7\20\2\2\u0083"+
		"\u0081\3\2\2\2\u0083\u0084\3\2\2\2\u0084\u0085\3\2\2\2\u0085\u0086\7\f"+
		"\2\2\u0086\u0087\7\16\2\2\u0087\u008b\7\21\2\2\u0088\u008a\5 \21\2\u0089"+
		"\u0088\3\2\2\2\u008a\u008d\3\2\2\2\u008b\u0089\3\2\2\2\u008b\u008c\3\2"+
		"\2\2\u008c\u008e\3\2\2\2\u008d\u008b\3\2\2\2\u008e\u008f\7\22\2\2\u008f"+
		"\u0091\7\26\2\2\u0090\u0083\3\2\2\2\u0091\u0092\3\2\2\2\u0092\u0090\3"+
		"\2\2\2\u0092\u0093\3\2\2\2\u0093\25\3\2\2\2\u0094\u0095\7\13\2\2\u0095"+
		"\u0096\7\16\2\2\u0096\u0097\7\20\2\2\u0097\u0098\5\32\16\2\u0098\u0099"+
		"\7\26\2\2\u0099\27\3\2\2\2\u009a\u009b\7\r\2\2\u009b\u009c\7\16\2\2\u009c"+
		"\u009d\7\20\2\2\u009d\u009e\7\16\2\2\u009e\u009f\7\21\2\2\u009f\u00a0"+
		"\5\32\16\2\u00a0\u00a1\7\22\2\2\u00a1\u00a2\t\2\2\2\u00a2\31\3\2\2\2\u00a3"+
		"\u00a4\7\16\2\2\u00a4\u00a6\7\23\2\2\u00a5\u00a3\3\2\2\2\u00a6\u00a9\3"+
		"\2\2\2\u00a7\u00a5\3\2\2\2\u00a7\u00a8\3\2\2\2\u00a8\u00aa\3\2\2\2\u00a9"+
		"\u00a7\3\2\2\2\u00aa\u00ab\7\16\2\2\u00ab\33\3\2\2\2\u00ac\u00bc\5\32"+
		"\16\2\u00ad\u00ae\7\16\2\2\u00ae\u00af\7\21\2\2\u00af\u00b0\t\3\2\2\u00b0"+
		"\u00b1\7\22\2\2\u00b1\u00b3\7\23\2\2\u00b2\u00ad\3\2\2\2\u00b3\u00b6\3"+
		"\2\2\2\u00b4\u00b2\3\2\2\2\u00b4\u00b5\3\2\2\2\u00b5\u00b7\3\2\2\2\u00b6"+
		"\u00b4\3\2\2\2\u00b7\u00b8\7\16\2\2\u00b8\u00b9\7\21\2\2\u00b9\u00ba\t"+
		"\3\2\2\u00ba\u00bc\7\22\2\2\u00bb\u00ac\3\2\2\2\u00bb\u00b4\3\2\2\2\u00bc"+
		"\35\3\2\2\2\u00bd\u00d1\5\32\16\2\u00be\u00bf\7\16\2\2\u00bf\u00c0\7\21"+
		"\2\2\u00c0\u00c1\t\3\2\2\u00c1\u00c2\7\23\2\2\u00c2\u00c3\t\3\2\2\u00c3"+
		"\u00c4\7\22\2\2\u00c4\u00c6\7\23\2\2\u00c5\u00be\3\2\2\2\u00c6\u00c9\3"+
		"\2\2\2\u00c7\u00c5\3\2\2\2\u00c7\u00c8\3\2\2\2\u00c8\u00ca\3\2\2\2\u00c9"+
		"\u00c7\3\2\2\2\u00ca\u00cb\7\16\2\2\u00cb\u00cc\7\21\2\2\u00cc\u00cd\t"+
		"\3\2\2\u00cd\u00ce\7\23\2\2\u00ce\u00cf\t\3\2\2\u00cf\u00d1\7\22\2\2\u00d0"+
		"\u00bd\3\2\2\2\u00d0\u00c7\3\2\2\2\u00d1\37\3\2\2\2\u00d2\u00d3\7\4\2"+
		"\2\u00d3\u00d4\7\16\2\2\u00d4\u00d6\7\23\2\2\u00d5\u00d2\3\2\2\2\u00d6"+
		"\u00d9\3\2\2\2\u00d7\u00d5\3\2\2\2\u00d7\u00d8\3\2\2\2\u00d8\u00da\3\2"+
		"\2\2\u00d9\u00d7\3\2\2\2\u00da\u00db\7\4\2\2\u00db\u00dc\7\16\2\2\u00dc"+
		"!\3\2\2\2\30(/\659>HMRX_dx\177\u0083\u008b\u0092\u00a7\u00b4\u00bb\u00c7"+
		"\u00d0\u00d7";
	public static final ATN _ATN =
		new ATNDeserializer().deserialize(_serializedATN.toCharArray());
	static {
		_decisionToDFA = new DFA[_ATN.getNumberOfDecisions()];
		for (int i = 0; i < _ATN.getNumberOfDecisions(); i++) {
			_decisionToDFA[i] = new DFA(_ATN.getDecisionState(i), i);
		}
	}
}